/**
 * 封装uni.request请求
 * 统一处理HTTP请求并自动处理认证错误
 */

// 基础URL
const BASE_URL = 'http://127.0.0.1:8081';

/**
 * 请求拦截器
 * @param {Object} config - 请求配置
 */
function requestInterceptor(config) {
  // 确保 header 对象存在
  config.header = config.header || {};
  
  // 添加token
  if (config.needToken !== false) {
    config.header['Authorization'] = uni.getStorageSync("token");
  }
  
  // 添加内容类型
  if (!config.header['Content-Type'] && config.method !== 'GET') {
    config.header['Content-Type'] = 'application/json';
  }
  
  return config;
}

/**
 * 响应拦截器
 * @param {Object} response - 响应对象
 * @param {Function} resolve - Promise成功回调
 * @param {Function} reject - Promise失败回调
 */
function responseInterceptor(response, resolve, reject) {
  // 检查HTTP状态码
  if (response.statusCode === 401) {
    // Token过期，重定向到登录页面
    uni.showToast({
      title: '登录已过期，请重新登录',
      icon: 'none'
    });
    
    setTimeout(() => {
      uni.reLaunch({
        url: '/pages/login/login'
      });
    }, 1500);
    
    reject({
      message: '登录已过期',
      code: 401
    });
    return;
  }
  
  // 检查响应数据是否存在
  if (!response.data) {
    uni.showToast({
      title: '返回数据为空',
      icon: 'none'
    });
    reject({
      message: '返回数据为空',
      code: -1
    });
    return;
  }
  
  // 获取响应数据
  const data = response.data;
  
  // 如果data不是对象，尝试进行JSON解析
  let parsedData = data;
  if (typeof data === 'string') {
    try {
      parsedData = JSON.parse(data);
    } catch (e) {
      parsedData = { code: 200, data: data, msg: 'success' };
    }
  }
  
  // 检查业务状态码
  if (parsedData.code === 200) {
    resolve(parsedData);
  } else {
    uni.showToast({
      title: parsedData.msg || `请求失败，状态码: ${parsedData.code || 'unknown'}`,
      icon: 'none'
    });
    reject(parsedData);
  }
}

/**
 * 统一请求方法
 * @param {Object} options - 请求配置
 * @returns {Promise} 请求Promise
 */
export function request(options) {
  // 构建请求URL
  const url = options.url.startsWith('http') ? options.url : BASE_URL + options.url;
  
  // 确保options中有header对象
  options.header = options.header || {};
  
  // 应用请求拦截器
  const config = requestInterceptor({
    ...options,
    url
  });
  
  return new Promise((resolve, reject) => {
    uni.request({
      ...config,
      success: (res) => {
        responseInterceptor(res, resolve, reject);
      },
      fail: (err) => {
        uni.showToast({
          title: `请求出错: ${err.errMsg}`,
          icon: 'none'
        });
        reject(err);
      }
    });
  });
}

/**
 * GET请求
 * @param {String} url - 请求路径
 * @param {Object} data - 请求参数
 * @param {Object} options - 其他配置
 * @returns {Promise} 请求Promise
 */
export function get(url, data = {}, options = {}) {
  return request({
    method: 'GET',
    url,
    data,
    ...options
  });
}

/**
 * POST请求
 * @param {String} url - 请求路径
 * @param {Object} data - 请求参数
 * @param {Object} options - 其他配置
 * @returns {Promise} 请求Promise
 */
export function post(url, data = {}, options = {}) {
  return request({
    method: 'POST',
    url,
    data,
    ...options
  });
}

/**
 * PUT请求
 * @param {String} url - 请求路径 
 * @param {Object} data - 请求参数
 * @param {Object} options - 其他配置
 * @returns {Promise} 请求Promise
 */
export function put(url, data = {}, options = {}) {
  return request({
    method: 'PUT',
    url,
    data,
    ...options
  });
}

/**
 * DELETE请求
 * @param {String} url - 请求路径
 * @param {Object} data - 请求参数
 * @param {Object} options - 其他配置
 * @returns {Promise} 请求Promise
 */
export function del(url, data = {}, options = {}) {
  return request({
    method: 'DELETE',
    url,
    data,
    ...options
  });
}

/**
 * 上传文件
 * @param {String} url - 上传地址
 * @param {String} filePath - 文件路径
 * @param {String} name - 文件对应的 key
 * @param {Object} formData - 附加的表单数据
 * @param {Object} options - 附加选项，包括 header
 * @returns {Promise} 上传Promise
 */
export function uploadFile(url, filePath, name = 'file', formData = {}, options = {}) {
  // 确保 header 对象存在
  const header = options.header || {};
  
  // 添加认证令牌
  if (options.needToken !== false) {
    header['Authorization'] = uni.getStorageSync("token");
  }
  
  return new Promise((resolve, reject) => {
    uni.uploadFile({
      url: url.startsWith('http') ? url : BASE_URL + url,
      filePath,
      name,
      formData,
      header,
      success: (res) => {
        if (res.statusCode === 401) {
          // Token过期
          uni.showToast({
            title: '登录已过期，请重新登录',
            icon: 'none'
          });
          
          setTimeout(() => {
            uni.reLaunch({
              url: '/pages/login/login'
            });
          }, 1500);
          
          reject({ message: '登录已过期', code: 401 });
          return;
        }
        
        // 解析响应数据
        let data;
        try {
          data = JSON.parse(res.data);
        } catch (e) {
          data = res.data;
        }
        
        if (data.code === 200) {
          resolve(data);
        } else {
          uni.showToast({
            title: data.msg || `上传失败，状态码: ${data.code}`,
            icon: 'none'
          });
          reject(data);
        }
      },
      fail: (err) => {
        uni.showToast({
          title: `上传出错: ${err.errMsg}`,
          icon: 'none'
        });
        reject(err);
      }
    });
  });
} 